home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / Development / ncurses-5.3 / tack / modes.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-27  |  20.5 KB  |  914 lines
  1. /*
  2. ** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
  3. ** 
  4. ** This file is part of TACK.
  5. ** 
  6. ** TACK is free software; you can redistribute it and/or modify
  7. ** it under the terms of the GNU General Public License as published by
  8. ** the Free Software Foundation; either version 2, or (at your option)
  9. ** any later version.
  10. ** 
  11. ** TACK is distributed in the hope that it will be useful,
  12. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ** GNU General Public License for more details.
  15. ** 
  16. ** You should have received a copy of the GNU General Public License
  17. ** along with TACK; see the file COPYING.  If not, write to
  18. ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. ** Boston, MA 02111-1307, USA.
  20. */
  21.  
  22. #include <tack.h>
  23.  
  24. MODULE_ID("$Id: modes.c,v 1.1 1998/01/10 00:29:53 tom Exp $")
  25.  
  26. /*
  27.  * Tests boolean flags and terminal modes.
  28.  */
  29. static void subtest_os(struct test_list *, int *, int *);
  30. static void subtest_rmam(struct test_list *, int *, int *);
  31. static void subtest_smam(struct test_list *, int *, int *);
  32. static void subtest_am(struct test_list *, int *, int *);
  33. static void subtest_ul(struct test_list *, int *, int *);
  34. static void subtest_uc(struct test_list *, int *, int *);
  35. static void subtest_bw(struct test_list *, int *, int *);
  36. static void subtest_xenl(struct test_list *, int *, int *);
  37. static void subtest_eo(struct test_list *, int *, int *);
  38. static void subtest_xmc(struct test_list *, int *, int *);
  39. static void subtest_xhp(struct test_list *, int *, int *);
  40. static void subtest_mir(struct test_list *, int *, int *);
  41. static void subtest_msgr(struct test_list *, int *, int *);
  42. static void subtest_tbc(struct test_list *, int *, int *);
  43. static void subtest_xt(struct test_list *, int *, int *);
  44. static void subtest_hts(struct test_list *, int *, int *);
  45. static void subtest_cbt(struct test_list *, int *, int *);
  46. static void subtest_in(struct test_list *, int *, int *);
  47. static void subtest_dadb(struct test_list *, int *, int *);
  48.  
  49. struct test_list mode_test_list[] = {
  50.     {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
  51.     {MENU_NEXT, 3, "os", 0, 0, subtest_os, 0},
  52.     {MENU_NEXT, 1, "rmam", 0, 0, subtest_rmam, 0},
  53.     {MENU_NEXT, 1, "smam", 0, 0, subtest_smam, 0},
  54.     {MENU_NEXT, 1, "am", 0, 0, subtest_am, 0},
  55.     {MENU_NEXT, 3, "ul", 0, 0, subtest_ul, 0},
  56.     {MENU_NEXT, 3, "uc", 0, 0, subtest_uc, 0},
  57.     {MENU_NEXT, 3, "bw", 0, 0, subtest_bw, 0},
  58.     {MENU_NEXT, 4, "xenl", 0, 0, subtest_xenl, 0},
  59.     {MENU_NEXT, 3, "eo", 0, 0, subtest_eo, 0},
  60.     {MENU_NEXT, 3, "xmc", 0, 0, subtest_xmc, 0},
  61.     {MENU_NEXT, 3, "xhp", 0, 0, subtest_xhp, 0},
  62.     {MENU_NEXT, 6, "mir", 0, 0, subtest_mir, 0},
  63.     {MENU_NEXT, 6, "msgr", 0, 0, subtest_msgr, 0},
  64.     {MENU_NEXT | MENU_CLEAR, 0, "tbc", "it", 0, subtest_tbc, 0},
  65.     {MENU_NEXT | MENU_CLEAR, 0, "hts", "it", 0, subtest_hts, 0},
  66.     {MENU_NEXT, 4, "xt", "it", 0, subtest_xt, 0},
  67.     {MENU_NEXT, 1, "cbt", "it", 0, subtest_cbt, 0},
  68.     {MENU_NEXT, 6, "in", 0, 0, subtest_in, 0},
  69.     {MENU_NEXT, 1, "da) (db", 0, 0, subtest_dadb, 0},
  70.     {MENU_LAST, 0, 0, 0, 0, 0, 0}
  71. };
  72.  
  73. /*
  74. **    subtest_os(test_list, status, ch)
  75. **
  76. **    test over strike mode (os)
  77. */
  78. static void
  79. subtest_os(
  80.     struct test_list *t,
  81.     int *state,
  82.     int *ch)
  83. {
  84.     ptext("(os) should be true, not false.");
  85.     put_cr();
  86.     ptextln("(os) should be           false.");
  87.     sprintf(temp, "(os) over-strike is %s in the data base.  ",
  88.         over_strike ? "true" : "false");
  89.     ptext(temp);
  90.     generic_done_message(t, state, ch);
  91. }
  92.  
  93. /*
  94. **    subtest_rmam(test_list, status, ch)
  95. **
  96. **    test exit automatic margins mode (rmam)
  97. */
  98. static void
  99. subtest_rmam(
  100.     struct test_list *t,
  101.     int *state,
  102.     int *ch)
  103. {
  104.     int j;
  105.  
  106.     if (!exit_am_mode) {
  107.         ptext("(rmam) not present.  ");
  108.     } else
  109.     if (!can_go_home) {
  110.         ptext("(rmam) not tested, no way to home cursor.  ");
  111.     } else
  112.     if (over_strike) {
  113.         put_clear();
  114.         go_home();
  115.         tc_putp(exit_am_mode);
  116.         ptext("\n(rmam) will     reset (am)");
  117.         go_home();
  118.         for (j = 0; j < columns; j++)
  119.             put_this(' ');
  120.         ptext("(rmam) will not reset (am)");
  121.         go_home();
  122.         put_newlines(2);
  123.     } else {
  124.         put_clear();
  125.         go_home();
  126.         tc_putp(exit_am_mode);
  127.         ptext("\n(rmam) will reset (am)");
  128.         go_home();
  129.         for (j = 0; j < columns; j++)
  130.             put_this(' ');
  131.         ptext("(rmam) will not reset (am) ");
  132.         go_home();
  133.         put_str("                          ");
  134.         go_home();
  135.         put_newlines(2);
  136.     }
  137.     ptext("Exit-automatic-margins ");
  138.     generic_done_message(t, state, ch);
  139. }
  140.  
  141. /*
  142. **    subtest_smam(test_list, status, ch)
  143. **
  144. **    test enter automatic margins mode (smam)
  145. */
  146. static void
  147. subtest_smam(
  148.     struct test_list *t,
  149.     int *state,
  150.     int *ch)
  151. {
  152.     int i, j;
  153.  
  154.     if (!enter_am_mode) {
  155.         ptext("(smam) not present.  ");
  156.     } else
  157.     if (!can_go_home) {
  158.         ptext("(smam) not tested, no way to home cursor.  ");
  159.     } else
  160.     if (over_strike) {
  161.         put_clear();
  162.         go_home();
  163.         tc_putp(enter_am_mode);
  164.         ptext("\n(smam) will ");
  165.         i = char_count;
  166.         ptext("not set (am)");
  167.         go_home();
  168.         for (j = -i; j < columns; j++)
  169.             put_this(' ');
  170.         put_str("@@@");
  171.         put_newlines(2);
  172.     } else {
  173.         put_clear();
  174.         go_home();
  175.         tc_putp(enter_am_mode);
  176.         ptext("\n(smam) will not set (am)");
  177.         go_home();
  178.         for (j = 0; j < columns; j++)
  179.             put_this(' ');
  180.         ptext("(smam) will set (am)    ");
  181.         go_home();
  182.         put_str("                          ");
  183.         put_newlines(2);
  184.     }
  185.     ptext("Enter-automatic-margins ");
  186.     generic_done_message(t, state, ch);
  187. }
  188.  
  189. /*
  190. **    subtest_am(test_list, status, ch)
  191. **
  192. **    test automatic margins (am)
  193. */
  194. static void
  195. subtest_am(
  196.     struct test_list *t,
  197.     int *state,
  198.     int *ch)
  199. {
  200.     int i, j;
  201.  
  202.     if (!can_go_home) {
  203.         ptextln("(am) not tested, no way to home cursor.  ");
  204.     } else
  205.     if (over_strike) {
  206.         put_clear();
  207.         go_home();
  208.         ptext("\n(am) should ");
  209.         i = char_count;
  210.         ptext("not be set");
  211.         go_home();
  212.         for (j = -i; j < columns; j++)
  213.             put_this(' ');
  214.         put_str("@@@");
  215.         go_home();
  216.         put_newlines(2);
  217.         sprintf(temp, "(am) is %s in the data base",
  218.             auto_right_margin ? "true" : "false");
  219.         ptextln(temp);
  220.     } else {
  221.         put_clear();
  222.         go_home();
  223.         ptext("\n(am) should not be set");
  224.         go_home();
  225.         for (j = 0; j < columns; j++)
  226.             put_this(' ');
  227.         ptext("(am) should be set    ");
  228.         go_home();
  229.         put_str("                       \n\n");
  230.         sprintf(temp, "(am) is %s in the data base",
  231.             auto_right_margin ? "true" : "false");
  232.         ptextln(temp);
  233.     }
  234.     ptext("Automatic-right-margin ");
  235.     generic_done_message(t, state, ch);
  236. }
  237.  
  238. /* Note: uprint() sends underscore back-space character, and
  239.         ucprint() sends character back-space underscore.  */
  240.  
  241. /*
  242. **    uprint(string)
  243. **
  244. **    underline string for (ul) test
  245. */
  246. static void
  247. uprint(const char *s)
  248. {
  249.     if (s) {
  250.         while (*s) {
  251.             put_str("_\b");
  252.             putchp(*s++);
  253.         }
  254.     }
  255. }
  256.  
  257. /*
  258. **    ucprint(string)
  259. **
  260. **    underline string for (uc) test
  261. */
  262. static void
  263. ucprint(const char *s)
  264. {
  265.     if (s) {
  266.         while (*s) {
  267.             putchp(*s++);
  268.             putchp('\b');
  269.             tc_putp(underline_char);
  270.         }
  271.     }
  272. }
  273.  
  274. /*
  275. **    subtest_ul(test_list, status, ch)
  276. **
  277. **    test transparent underline (ul)
  278. */
  279. static void
  280. subtest_ul(
  281.     struct test_list *t,
  282.     int *state,
  283.     int *ch)
  284. {
  285.     if (!over_strike) {
  286.         /* (ul) is used only if (os) is reset */
  287.         put_crlf();
  288.         sprintf(temp, "This text should %sbe underlined.",
  289.             transparent_underline ? "" : "not ");
  290.         uprint(temp);
  291.         put_crlf();
  292.         ptextln("If the above line is not underlined the (ul) should be false.");
  293.         sprintf(temp, "(ul) Transparent-underline is %s in the data base",
  294.             transparent_underline ? "true" : "false");
  295.         ptextln(temp);
  296.         generic_done_message(t, state, ch);
  297.     }
  298. }
  299.  
  300. /*
  301. **    subtest_uc(test_list, status, ch)
  302. **
  303. **    test underline character (uc)
  304. */
  305. static void
  306. subtest_uc(
  307.     struct test_list *t,
  308.     int *state,
  309.     int *ch)
  310. {
  311.     if (!over_strike) {
  312.         if (underline_char) {
  313.             ucprint("This text should be underlined.");
  314.             put_crlf();
  315.             ptextln("If the above text is not underlined the (uc) has failed.");
  316.             ptext("Underline-character ");
  317.         } else {
  318.             ptext("(uc) underline-character is not defined.  ");
  319.         }
  320.         generic_done_message(t, state, ch);
  321.     }
  322. }
  323.  
  324. /*
  325. **    subtest_bw(test_list, status, ch)
  326. **
  327. **    test auto left margin (bw)
  328. */
  329. static void
  330. subtest_bw(
  331.     struct test_list *t,
  332.     int *state,
  333.     int *ch)
  334. {
  335.     int i, j;
  336.  
  337.     if (over_strike) {
  338.         /* test (bw) */
  339.         ptext("\n(bw) should ");
  340.         i = char_count;
  341.         ptextln("not be set.");
  342.         for (j = i; j < columns; j++)
  343.             put_str("\b");
  344.         put_str("@@@");
  345.         put_crlf();
  346.         sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
  347.             auto_left_margin ? "true" : "false");
  348.         ptextln(temp);
  349.     } else {
  350.         /* test (bw) */
  351.         ptextln("(bw) should not be set.");
  352.         for (i = 12; i < columns; i++)
  353.             put_str("\b");
  354.         if (delete_character) {
  355.             for (i = 0; i < 4; i++)
  356.                 tc_putp(delete_character);
  357.         } else {
  358.             put_str("   ");
  359.         }
  360.         put_crlf();
  361.         sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
  362.             auto_left_margin ? "true" : "false");
  363.         ptextln(temp);
  364.     }
  365.     generic_done_message(t, state, ch);
  366. }
  367.  
  368. /*
  369. **    subtest_tbc(test_list, status, ch)
  370. **
  371. **    test clear tabs (tbc)
  372. */
  373. static void
  374. subtest_tbc(
  375.     struct test_list *t,
  376.     int *state,
  377.     int *ch)
  378. {
  379.     int tabat;        /* the tab spacing we end up with */
  380.     int i;
  381.  
  382.     if (clear_all_tabs && !set_tab) {
  383.         ptext("(tbc) Clear-all-tabs is defined but (hts) set-tab is not.  ");
  384.         ptext("Once the tabs are cleared there is no way to set them.  ");
  385.     } else
  386.     if (clear_all_tabs) {
  387.         tabat = set_tab ? 8 : init_tabs;
  388.         tc_putp(clear_all_tabs);
  389.         ptext("Clear tabs (tbc)");
  390.         go_home();
  391.         put_crlf();
  392.         putchp('\t');
  393.         putchp('T');
  394.         go_home();
  395.         put_newlines(2);
  396.         for (i = 0; i < columns; i++) {
  397.             if (i == tabat) {
  398.                 putchp('T');
  399.             } else {
  400.                 putchp('.');
  401.             }
  402.         }
  403.         go_home();
  404.         ptext("\n\n\nIf the above two lines have T's in the same column then (tbc) has failed.  ");
  405.     } else {
  406.         ptext("(tbc) Clear-all-tabs is not defined.  ");
  407.     }
  408.     generic_done_message(t, state, ch);
  409. }
  410.  
  411. /*
  412. **    subtest_hts(test_list, status, ch)
  413. **
  414. **    (ht) and set tabs with (hts)
  415. */
  416. static void
  417. subtest_hts(
  418.     struct test_list *t,
  419.     int *state,
  420.     int *ch)
  421. {
  422.     int tabat;        /* the tab spacing we end up with */
  423.     int i;
  424.  
  425.     tabat = init_tabs;
  426.     if (set_tab) {
  427.         ptext("Tabs set with (hts)");
  428.         put_crlf();
  429.         for (i = 1; i < columns; i++) {
  430.             if (i % 8 == 1) {
  431.                 tc_putp(set_tab);
  432.             }
  433.             putchp(' ');
  434.         }
  435.         tabat = 8;
  436.     } else {
  437.         sprintf(temp, "(hts) Set-tabs not defined.  (it) Initial-tabs at %d", init_tabs);
  438.         ptext(temp);
  439.     }
  440.     go_home();
  441.     put_newlines(2);
  442.     if (tabat <= 0) {
  443.         tabat = 8;
  444.     }
  445.     for (i = tabat; i < columns; i += tabat) {
  446.         putchp('\t');
  447.         putchp('T');
  448.     }
  449.     go_home();
  450.     put_newlines(3);
  451.     for (i = 1; i < columns; i++) {
  452.         putchp('.');
  453.     }
  454.     go_home();
  455.     put_newlines(3);
  456.     for (i = tabat; i < columns; i += tabat) {
  457.         putchp('\t');
  458.         putchp('T');
  459.     }
  460.     go_home();
  461.     put_newlines(4);
  462.     putchp('.');
  463.     for (i = 2; i < columns; i++) {
  464.         if (i % tabat == 1) {
  465.             putchp('T');
  466.         } else {
  467.             putchp('.');
  468.         }
  469.     }
  470.     go_home();
  471.     put_newlines(5);
  472.     if (set_tab) {
  473.         ptextln("If the last two lines are not the same then (hts) has failed.");
  474.     } else
  475.     if (init_tabs > 0) {
  476.         ptextln("If the last two lines are not the same then (it) is wrong.");
  477.     } else {
  478.         ptextln("If the last two lines are the same then maybe you do have tabs and (it) should be changed.");
  479.     }
  480.     generic_done_message(t, state, ch);
  481. }
  482.  
  483. /*
  484. **    subtest_xt(test_list, status, ch)
  485. **
  486. **    (xt) glitch
  487. */
  488. static void
  489. subtest_xt(
  490.     struct test_list *t,
  491.     int *state,
  492.     int *ch)
  493. {
  494.     int tabat;        /* the tab spacing we end up with */
  495.     int cc;
  496.  
  497.     tabat = set_tab ? 8 : init_tabs;
  498.     if (!over_strike && (tabat > 0)) {
  499.         ptext("(xt) should not ");
  500.         put_cr();
  501.         ptext("(xt) should");
  502.         cc = char_count;
  503.         while (cc < 16) {
  504.             putchp('\t');
  505.             cc = ((cc / tabat) + 1) * tabat;
  506.         }
  507.         putln("be set.");
  508.         sprintf(temp, "(xt) Destructive-tab is %s in the data base.",
  509.             dest_tabs_magic_smso ? "true" : "false");
  510.         ptextln(temp);
  511.         generic_done_message(t, state, ch);
  512.     }
  513. }
  514.  
  515. /*
  516. **    subtest_cbt(test_list, status, ch)
  517. **
  518. **    (cbt) back tab
  519. */
  520. static void
  521. subtest_cbt(
  522.     struct test_list *t,
  523.     int *state,
  524.     int *ch)
  525. {
  526.     int i;
  527.  
  528.     if (back_tab) {
  529.         put_clear();
  530.         ptext("Back-tab (cbt)");
  531.         go_home();
  532.         put_crlf();
  533.         for (i = 1; i < columns; i++) {
  534.             putchp(' ');
  535.         }
  536.         for (i = 0; i < columns; i += 8) {
  537.             tc_putp(back_tab);
  538.             putchp('T');
  539.             tc_putp(back_tab);
  540.         }
  541.         go_home();
  542.         put_newlines(2);
  543.         for (i = 1; i < columns; i++) {
  544.             if (i % 8 == 1) {
  545.                 putchp('T');
  546.             } else {
  547.                 putchp(' ');
  548.             }
  549.         }
  550.         go_home();
  551.         put_newlines(3);
  552.         ptextln("The preceding two lines should be the same.");
  553.     } else {
  554.         ptextln("(cbt) Back-tab not present");
  555.     }
  556.     generic_done_message(t, state, ch);
  557. }
  558.  
  559. /*
  560. **    subtest_xenl(test_list, status, ch)
  561. **
  562. **    (xenl) eat newline glitch
  563. */
  564. static void
  565. subtest_xenl(
  566.     struct test_list *t,
  567.     int *state,
  568.     int *ch)
  569. {
  570.     int i, j, k;
  571.  
  572.     if (over_strike) {
  573.         /* test (xenl) on overstrike terminals */
  574.         if (!can_go_home || !can_clear_screen) {
  575.             ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear.");
  576.             generic_done_message(t, state, ch);
  577.             return;
  578.         }
  579.         put_clear();
  580.         /*
  581.            this test must be done in raw mode.  Otherwise UNIX will
  582.            translate CR to CRLF.
  583.         */
  584.         if (stty_query(TTY_OUT_TRANS))
  585.             tty_raw(1, char_mask);
  586.         ptext("\nreset (xenl). Does ");
  587.         i = char_count;
  588.         put_str("not ignore CR, does ");
  589.         k = char_count;
  590.         put_str("not ignore LF");
  591.         go_home();
  592.         for (j = 0; j < columns; j++)
  593.             put_this(' ');
  594.         put_cr();
  595.         for (j = 0; j < i; j++)
  596.             putchp(' ');
  597.         put_str("@@@\n@@");
  598.         go_home();
  599.         for (j = 0; j < columns; j++)
  600.             put_this(' ');
  601.         put_lf();
  602.         for (j = 0; j < k; j++)
  603.             putchp(' ');
  604.         put_str("@@@\r@@");
  605.         tty_set();
  606.         go_home();
  607.         put_newlines(4);
  608.         sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
  609.             eat_newline_glitch ? "true" : "false");
  610.         ptextln(temp);
  611.     } else {
  612.         /* test (xenl) when (os) is reset */
  613.         if (!can_go_home) {
  614.             ptextln("(xenl) Newline-glitch not tested, can't home cursor");
  615.             generic_done_message(t, state, ch);
  616.             return;
  617.         }
  618.         /* (xenl) test */
  619.         put_clear();
  620.         /*
  621.            this test must be done in raw mode.  Otherwise
  622.            UNIX will translate CR to CRLF.
  623.         */
  624.         if (stty_query(TTY_OUT_TRANS))
  625.             tty_raw(1, char_mask);
  626.         for (j = 0; j < columns; j++)
  627.             put_this(' ');
  628.         put_cr();
  629.         ptext("(xenl) should be set. Does not ignore CR");
  630.         go_home();
  631.         put_crlf();
  632.         for (j = 0; j < columns; j++)
  633.             put_this(' ');
  634.         put_lf();    /* test (cud1) */
  635.         ptext("(xenl) should be set. Ignores (cud1)");
  636.         go_home();
  637.         put_newlines(3);
  638.         if (scroll_forward && cursor_down &&
  639.             strcmp(scroll_forward, cursor_down)) {
  640.             for (j = 0; j < columns; j++)
  641.                 put_this(' ');
  642.             put_ind();    /* test (ind) */
  643.             ptext("(xenl) should be set. Ignores (ind)");
  644.             go_home();
  645.             put_newlines(5);
  646.         }
  647.         tty_set();
  648.         ptextln("If you don't see text above telling you to set it, (xenl) should be false");
  649.         sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
  650.             eat_newline_glitch ? "true" : "false");
  651.         ptextln(temp);
  652.     }
  653.     generic_done_message(t, state, ch);
  654. }
  655.  
  656. /*
  657. **    subtest_eo(test_list, status, ch)
  658. **
  659. **    (eo) erase overstrike
  660. */
  661. static void
  662. subtest_eo(
  663.     struct test_list *t,
  664.     int *state,
  665.     int *ch)
  666. {
  667.     if (transparent_underline || over_strike || underline_char) {
  668.         ptext("(eo) should ");
  669.         if (underline_char) {
  670.             ucprint("not");
  671.         } else {
  672.             uprint("not");
  673.         }
  674.         put_cr();
  675.         ptextln("(eo) should     be set");
  676.         sprintf(temp, "\n(eo) Erase-overstrike is %s in the data base",
  677.             erase_overstrike ? "true" : "false");
  678.         ptextln(temp);
  679.         generic_done_message(t, state, ch);
  680.     }
  681. }
  682.  
  683. /*
  684. **    subtest_xmc(test_list, status, ch)
  685. **
  686. **    (xmc) magic cookie glitch
  687. */
  688. static void
  689. subtest_xmc(
  690.     struct test_list *t,
  691.     int *state,
  692.     int *ch)
  693. {
  694.     int i, j;
  695.  
  696.     if (enter_standout_mode) {
  697.         sprintf(temp, "\n(xmc) Magic-cookie-glitch is %d in the data base", magic_cookie_glitch);
  698.         ptextln(temp);
  699.         j = magic_cookie_glitch * 8;
  700.         for (i = 0; i < j; i++) {
  701.             put_str(" ");
  702.         }
  703.         ptextln("        These two lines should line up.");
  704.         if (j > 0) {
  705.             char_count += j;
  706.         }
  707.         for (i = 0; i < 4; i++) {
  708.             put_mode(enter_standout_mode);
  709.             putchp(' ');
  710.             put_mode(exit_standout_mode);
  711.             putchp(' ');
  712.         }
  713.         ptextln("These two lines should line up.");
  714.         ptext("If they don't line up then (xmc) magic-cookie-glitch should be greater than zero.  ");
  715.         generic_done_message(t, state, ch);
  716.     }
  717. }
  718.  
  719. /*
  720. **    subtest_xhp(test_list, status, ch)
  721. **
  722. **    (xhp) erase does not clear standout mode
  723. */
  724. static void
  725. subtest_xhp(
  726.     struct test_list *t,
  727.     int *state,
  728.     int *ch)
  729. {
  730.     if (enter_standout_mode) {
  731.         put_crlf();
  732.         put_mode(enter_standout_mode);
  733.         put_str("Stand out");
  734.         put_mode(exit_standout_mode);
  735.         put_cr();
  736.         ptextln("If any part of this line is standout then (xhp) should be set.");
  737.         sprintf(temp, "(xhp) Erase-standout-glitch is %s in the data base",
  738.             ceol_standout_glitch ? "true" : "false");
  739.         ptextln(temp);
  740.         generic_done_message(t, state, ch);
  741.     }
  742. }
  743.  
  744. /*
  745. **    subtest_mir(test_list, status, ch)
  746. **
  747. **    (mir) move in insert mode
  748. */
  749. static void
  750. subtest_mir(
  751.     struct test_list *t,
  752.     int *state,
  753.     int *ch)
  754. {
  755.     int i;
  756.     char *s;
  757.  
  758.     if (enter_insert_mode && exit_insert_mode && cursor_address) {
  759.         put_clear();
  760.         i = line_count;
  761.         put_str("\nXXX\nXXX\nXXX\nXXX");
  762.         tc_putp(enter_insert_mode);
  763.         s = tparm(cursor_address, i + 1, 0);
  764.         tputs(s, lines, tc_putch);
  765.         putchp('X');
  766.         s = tparm(cursor_address, i + 2, 1);
  767.         tputs(s, lines, tc_putch);
  768.         putchp('X');
  769.         s = tparm(cursor_address, i + 3, 2);
  770.         tputs(s, lines, tc_putch);
  771.         putchp('X');
  772.         s = tparm(cursor_address, i + 4, 3);
  773.         tputs(s, lines, tc_putch);
  774.         putchp('X');
  775.         tc_putp(exit_insert_mode);
  776.         put_newlines(2);
  777.         ptextln("If you see a 4 by 4 block of X's then (mir) should be true.");
  778.         sprintf(temp, "(mir) Move-in-insert-mode is %s in the data base",
  779.             move_insert_mode ? "true" : "false");
  780.         ptextln(temp);
  781.     } else {
  782.         ptext("(mir) Move-in-insert-mode not tested, ");
  783.         if (!enter_insert_mode) {
  784.             ptext("(smir) ");
  785.         }
  786.         if (!exit_insert_mode) {
  787.             ptext("(rmir) ");
  788.         }
  789.         if (!cursor_address) {
  790.             ptext("(cup) ");
  791.         }
  792.         ptext("not present.  ");
  793.     }
  794.     generic_done_message(t, state, ch);
  795. }
  796.  
  797. /*
  798. **    subtest_msgr(test_list, status, ch)
  799. **
  800. **    (msgr) move in sgr mode
  801. */
  802. static void
  803. subtest_msgr(
  804.     struct test_list *t,
  805.     int *state,
  806.     int *ch)
  807. {
  808.     int i;
  809.  
  810.     if (cursor_address &&
  811.         ((enter_standout_mode && exit_standout_mode) ||
  812.         (enter_alt_charset_mode && exit_alt_charset_mode))) {
  813.         put_crlf();
  814.         i = line_count + 1;
  815.         tputs(tparm(cursor_address, i, 0), lines, tc_putch);
  816.         put_mode(enter_alt_charset_mode);
  817.         put_crlf();
  818.         /*
  819.            some versions of the wy-120 can not clear lines or
  820.            screen when in alt charset mode.  If (el) and (ed)
  821.            are defined then I can test them.  If they are not
  822.            defined then they can not break (msgr)
  823.         */
  824.         tc_putp(clr_eos);
  825.         tc_putp(clr_eol);
  826.         put_mode(exit_alt_charset_mode);
  827.         put_mode(enter_standout_mode);
  828.         putchp('X');
  829.         tputs(tparm(cursor_address, i + 2, 1), lines, tc_putch);
  830.         putchp('X');
  831.         tputs(tparm(cursor_address, i + 3, 2), lines, tc_putch);
  832.         putchp('X');
  833.         tputs(tparm(cursor_address, i + 4, 3), lines, tc_putch);
  834.         putchp('X');
  835.         put_mode(exit_standout_mode);
  836.         put_crlf();
  837.         tc_putp(clr_eos);    /* OK if missing */
  838.         put_crlf();
  839.         ptextln("If you see a diagonal line of standout X's then (msgr) should be true.  If any of the blanks are standout then (msgr) should be false.");
  840.         sprintf(temp, "(msgr) Move-in-SGR-mode is %s in the data base",
  841.             move_standout_mode ? "true" : "false");
  842.         ptextln(temp);
  843.     } else {
  844.         ptextln("(smso) (rmso) (smacs) (rmacs) missing; (msgr) Move-in-SGR-mode not tested.");
  845.     }
  846.     generic_done_message(t, state, ch);
  847. }
  848.  
  849. /*
  850. **    subtest_in(test_list, status, ch)
  851. **
  852. **    (in) insert null glitch
  853. */
  854. static void
  855. subtest_in(
  856.     struct test_list *t,
  857.     int *state,
  858.     int *ch)
  859. {
  860.     if (enter_insert_mode && exit_insert_mode) {
  861.         ptextln("\nTesting (in) with (smir) and (rmir)");
  862.         putln("\tIf these two lines line up ...");
  863.         put_str("\tIf these two lines line up ...");
  864.         put_cr();
  865.         tc_putp(enter_insert_mode);
  866.         putchp(' ');
  867.         tc_putp(exit_insert_mode);
  868.         ptext("\nthen (in) should be set.  ");
  869.         sprintf(temp,
  870.             "(in) Insert-null-glitch is %s in the data base.",
  871.             insert_null_glitch ? "true" : "false");
  872.         ptextln(temp);
  873.         generic_done_message(t, state, ch);
  874.     }
  875. }
  876.  
  877. /*
  878. **    subtest_dadb(test_list, status, ch)
  879. **
  880. **    (da) (db) data above, (db) data below
  881. */
  882. static void
  883. subtest_dadb(
  884.     struct test_list *t,
  885.     int *state,
  886.     int *ch)
  887. {
  888.     if (can_clear_screen && scroll_reverse && scroll_forward) {
  889.         put_clear();
  890.         if (scroll_reverse)
  891.             ptext("(da) Data-above should be set\r");
  892.         home_down();
  893.         if (scroll_forward)
  894.             ptext("(db) Data-below should be set\r");
  895.         tc_putp(scroll_forward);
  896.         go_home();
  897.         tc_putp(scroll_reverse);
  898.         tc_putp(scroll_reverse);
  899.         home_down();
  900.         tc_putp(scroll_forward);
  901.         go_home();
  902.         ptextln("\n\n\n\n\nIf the top line is blank then (da) should be false.");
  903.         ptextln("If the bottom line is blank then (db) should be false.");
  904.         sprintf(temp, "\n(da) Data-above is %s, and (db) Data-below is %s, in the data base.",
  905.             memory_above ? "true" : "false",
  906.             memory_below ? "true" : "false");
  907.         ptextln(temp);
  908.         line_count = lines;
  909.     } else {
  910.         ptextln("(da) Data-above, (db) Data-below not tested, scrolls or (clear) is missing.");
  911.     }
  912.     generic_done_message(t, state, ch);
  913. }
  914.